import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { useUserStore } from './user'
import { userDataSyncApi, syncManager } from '@/utils/userDataSyncApi'
import { articleApi } from '@/utils/api'
import { showToast, showFailToast } from 'vant'

export const useFavoritesStore = defineStore('favorites', () => {
  // 状态定义
  const favoriteIds = ref([])
  const favoriteArticles = ref([])
  const loading = ref(false)
  const syncLoading = ref(false) // 同步加载状态

  // 获取用户store
  const userStore = useUserStore()

  // 计算属性
  const favoriteCount = computed(() => favoriteIds.value.length)

  const isFavorited = computed(() => (newsId) => {
    return favoriteIds.value.includes(newsId)
  })

  const isEmpty = computed(() => favoriteIds.value.length === 0)

  // 获取存储key
  const getStorageKey = () => {
    if (userStore.isLoggedIn && userStore.userInfo.username) {
      return `favorites_${userStore.userInfo.username}`
    }
    return 'local_favorites'
  }

  // Actions
  const initFavorites = () => {
    try {
      const storageKey = getStorageKey()
      const savedFavorites = localStorage.getItem(storageKey)

      if (savedFavorites) {
        favoriteIds.value = JSON.parse(savedFavorites)
        console.log(`从${storageKey}恢复收藏数据:`, favoriteIds.value.length, '条')
      } else {
        // 如果当前key没有数据，尝试从旧的key迁移数据
        const oldFavorites = localStorage.getItem('favorites')
        if (oldFavorites) {
          favoriteIds.value = JSON.parse(oldFavorites)
          saveFavorites() // 保存到新key
          localStorage.removeItem('favorites') // 删除旧key
          console.log('迁移旧收藏数据到新存储格式')
        }
      }
    } catch (error) {
      console.error('初始化收藏数据失败:', error)
      favoriteIds.value = []
    }
  }

  const saveFavorites = () => {
    const storageKey = getStorageKey()
    localStorage.setItem(storageKey, JSON.stringify(favoriteIds.value))
    console.log(`收藏数据已保存到${storageKey}:`, favoriteIds.value.length, '条')
  }

  const addFavorite = async (newsId, articleData = null) => {
    // 确保newsId是正确的类型（统一转换为字符串存储在本地）
    const normalizedNewsId = String(newsId)

    if (!favoriteIds.value.includes(normalizedNewsId)) {
      favoriteIds.value.push(normalizedNewsId)
      saveFavorites()

      // 如果用户已登录，同步到服务器
      if (userStore.isLoggedIn) {
        try {
          await syncFavoriteToServer(newsId, 'add', articleData)
        } catch (error) {
          console.error('同步收藏失败，但本地收藏已保存:', error)
          // 本地收藏已保存，同步失败不影响用户体验
        }
      }

      return true
    }
    return false
  }

  const removeFavorite = async (newsId) => {
    console.log(`=== 开始删除收藏操作 ===`)
    console.log(`目标文章ID: ${newsId} (类型: ${typeof newsId})`)
    console.log(`当前收藏ID列表 (${favoriteIds.value.length}条):`, favoriteIds.value)

    // 标准化newsId为字符串，确保一致性
    const normalizedNewsId = String(newsId)

    // 查找要删除的文章在收藏列表中的位置
    let index = favoriteIds.value.findIndex(id => String(id) === normalizedNewsId)

    console.log(`查找结果: index=${index}, 标准化ID=${normalizedNewsId}`)

    // 如果找不到，尝试数字匹配（兼容性处理）
    if (index === -1) {
      const numNewsId = Number(newsId)
      if (!isNaN(numNewsId)) {
        index = favoriteIds.value.findIndex(id => Number(id) === numNewsId)
        console.log(`数字匹配结果: index=${index}, 数字ID=${numNewsId}`)
      }
    }

    if (index > -1) {
      console.log(`找到匹配的收藏ID，索引: ${index}`)
      favoriteIds.value.splice(index, 1)

      // 同时从文章列表中移除
      const articleIndex = favoriteArticles.value.findIndex(
        article => {
          const articleId = article.news_id || article.newsId
          // 使用相同的匹配逻辑
          return articleId === newsId ||
                 String(articleId) === String(newsId) ||
                 Number(articleId) === Number(newsId)
        }
      )

      if (articleIndex > -1) {
        console.log(`从文章列表中移除，索引: ${articleIndex}`)
        favoriteArticles.value.splice(articleIndex, 1)
      }

      saveFavorites()

      console.log(`✓ 本地删除成功，剩余收藏数量: ${favoriteIds.value.length}`)

      // 如果用户已登录，同步到服务器
      if (userStore.isLoggedIn) {
        try {
          console.log(`开始同步删除到服务器: ${newsId}`)
          await syncFavoriteToServer(newsId, 'remove')
          console.log(`✓ 服务器同步删除成功: ${newsId}`)
        } catch (error) {
          console.error(`✗ 服务器同步删除失败: ${newsId}`, error)
          // 本地删除已完成，同步失败不影响用户体验，错误处理在syncFavoriteToServer中
        }
      } else {
        console.log('用户未登录，跳过服务器同步')
      }

      console.log(`=== 删除收藏操作完成: ${newsId} ===`)
      return true
    }

    console.log(`✗ 未找到匹配的收藏文章 ID: ${newsId}`)
    console.log(`=== 删除收藏操作失败: ${newsId} ===`)
    return false
  }

  const toggleFavorite = async (newsId) => {
    if (isFavorited.value(newsId)) {
      await removeFavorite(newsId)
      return { action: 'removed', isFavorited: false }
    } else {
      await addFavorite(newsId)
      return { action: 'added', isFavorited: true }
    }
  }

  // 同步收藏到服务器的方法
  const syncFavoriteToServer = async (newsId, action, articleData = null) => {
    try {
      syncLoading.value = true
      console.log(`同步收藏到服务器 - 文章ID: ${newsId}, 操作: ${action}`)

      // 确保newsId是整数类型
      const numericNewsId = parseInt(newsId)
      if (isNaN(numericNewsId)) {
        throw new Error(`无效的文章ID: ${newsId}`)
      }

      if (action === 'add') {
        // 获取文章详情（如果没有提供）
        let article = articleData
        if (!article) {
          try {
            console.log(`尝试获取文章 ${numericNewsId} 的详情`)
            const response = await articleApi.getArticleDetail(numericNewsId)

            // 改进响应处理逻辑
            if (response && response.code === 200 && response.data) {
              article = response.data
              console.log(`成功获取文章 ${numericNewsId} 详情:`, article.title)
            } else if (response && typeof response === 'object' && (response.news_id || response.newsId)) {
              // 直接返回文章数据的情况
              article = response
              console.log(`直接获取文章 ${numericNewsId} 数据:`, article.title)
            } else {
              // 响应格式异常，但不抛出错误
              console.warn(`文章 ${numericNewsId} 响应格式异常:`, response)
              throw new Error(`响应格式异常: ${JSON.stringify(response)}`)
            }
          } catch (error) {
            console.warn(`获取文章 ${numericNewsId} 详情失败，使用基本信息:`, error.message)

            // 根据错误类型提供不同的处理
            let title = `文章 ${numericNewsId}`
            if (error.response?.status === 404) {
              title = `文章 ${numericNewsId} (已删除)`
              console.warn(`文章 ${numericNewsId} 不存在，可能已被删除`)
            } else if (error.response?.status >= 500) {
              title = `文章 ${numericNewsId} (服务器错误)`
              console.warn(`获取文章 ${numericNewsId} 时服务器错误`)
            }

            // 使用基本信息创建文章对象，确保收藏功能不受影响
            article = {
              news_id: numericNewsId,
              title: title,
              url: `/news/${numericNewsId}`,
              category: '',
              section: ''
            }
          }
        }

        // 构造收藏数据
        const favoriteData = [{
          newsId: numericNewsId,
          title: article.title || `文章 ${numericNewsId}`,
          url: article.url || `/news/${numericNewsId}`,
          category: article.category || '',
          section: article.section || '',
          favoriteTime: new Date().toISOString()
        }]

        // 上传收藏数据
        const result = await userDataSyncApi.uploadFavorites(favoriteData, {
          overwriteConflicts: true // 允许覆盖已存在的收藏
        })

        if (result.code === 200 && result.data.success) {
          console.log('收藏同步成功:', result.data)
          showToast('收藏已同步到服务器')
        } else {
          throw new Error(result.data?.errorMessage || '同步失败')
        }

      } else if (action === 'remove') {
        // 删除收藏：使用更直接的删除方式
        try {
          console.log(`开始删除服务器收藏文章 ${numericNewsId}`)

          // 方法1: 尝试使用直接删除API（如果后端支持）
          try {
            const deleteResult = await userDataSyncApi.deleteFavorite(numericNewsId)
            if (deleteResult.code === 200 && deleteResult.data.success) {
              console.log(`直接删除收藏 ${numericNewsId} 成功`)
              showToast('已从服务器移除收藏')
              return
            }
          } catch (directDeleteError) {
            console.log('直接删除API不可用，使用替代方案:', directDeleteError.message)
          }

          // 方法2: 使用上传方式删除（原有逻辑的改进版本）
          const downloadResult = await userDataSyncApi.downloadUserData(['favorite'])

          if (downloadResult.code === 200 && downloadResult.data.success) {
            const serverFavorites = downloadResult.data.downloadData || []
            console.log(`服务器当前收藏数量: ${serverFavorites.length}`)

            // 检查要删除的文章是否存在
            const targetExists = serverFavorites.some(item => item.newsId === numericNewsId)
            if (!targetExists) {
              console.log(`文章 ${numericNewsId} 在服务器上不存在，无需删除`)
              showToast('收藏已移除')
              return
            }

            // 从服务器收藏列表中移除指定文章
            const filteredFavorites = serverFavorites
              .filter(item => item.newsId !== numericNewsId)
              .map(item => ({
                newsId: item.newsId,
                title: item.newsTitle,
                url: item.newsUrl,
                category: item.newsCategory,
                section: item.newsSection,
                favoriteTime: item.createTime
              }))

            console.log(`过滤后收藏数量: ${filteredFavorites.length}`)

            // 重新上传过滤后的收藏列表，使用强制覆盖模式
            const uploadResult = await userDataSyncApi.uploadFavorites(filteredFavorites, {
              overwriteConflicts: true,
              deleteLocalMissing: true,
              forceReplace: true // 强制替换所有数据
            })

            if (uploadResult.code === 200 && uploadResult.data.success) {
              console.log(`取消收藏 ${numericNewsId} 同步成功:`, uploadResult.data)
              showToast('已从服务器移除收藏')
            } else {
              throw new Error(uploadResult.data?.errorMessage || '取消收藏同步失败')
            }
          } else {
            throw new Error('无法获取服务器收藏列表')
          }
        } catch (error) {
          console.error(`删除服务器收藏 ${numericNewsId} 失败:`, error)
          // 加入离线队列，网络恢复时重试
          syncManager.addToSyncQueue({
            syncType: 'remove_favorite',
            newsId: numericNewsId,
            action: 'remove'
          })
          showToast('网络异常，将在网络恢复时同步删除')
        }
      }

    } catch (error) {
      console.error(`同步收藏到服务器失败 (文章ID: ${numericNewsId}, 操作: ${action}):`, error)

      // 详细的错误分类和处理
      let errorMessage = '同步失败'
      let shouldShowToast = true

      if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
        // 请求超时
        errorMessage = '请求超时，请检查网络连接'
        console.warn(`文章 ${numericNewsId} 同步超时，加入离线队列`)
      } else if (error.response?.status === 401) {
        // 未登录或登录过期
        errorMessage = '登录已过期，请重新登录'
        console.warn(`文章 ${numericNewsId} 同步失败：未登录`)
      } else if (error.response?.status === 403) {
        // 权限不足
        errorMessage = '权限不足，无法同步收藏'
        console.warn(`文章 ${numericNewsId} 同步失败：权限不足`)
      } else if (error.response?.status === 404) {
        // 文章不存在
        errorMessage = '文章不存在，但本地收藏已保存'
        console.warn(`文章 ${numericNewsId} 不存在，但本地收藏已保存`)
      } else if (error.response?.status >= 500) {
        // 服务器错误
        errorMessage = '服务器暂时不可用，将稍后重试'
        console.warn(`文章 ${numericNewsId} 同步失败：服务器错误`)
      } else if (error.message?.includes('网络') || error.code === 'NETWORK_ERROR') {
        // 网络错误
        errorMessage = '网络异常，将在网络恢复时同步'
        console.warn(`文章 ${numericNewsId} 同步失败：网络错误`)
      } else {
        // 其他未知错误
        errorMessage = `同步失败: ${error.message || '未知错误'}`
        console.error(`文章 ${numericNewsId} 同步失败：未知错误`, error)
      }

      // 对于网络相关错误，加入离线队列
      if (error.code === 'ECONNABORTED' ||
          error.message?.includes('网络') ||
          error.code === 'NETWORK_ERROR' ||
          error.response?.status >= 500) {

        console.log(`将文章 ${numericNewsId} 的 ${action} 操作加入离线同步队列`)
        syncManager.addToSyncQueue({
          syncType: action === 'add' ? 'upload' : 'delete',
          dataTypes: ['favorite'],
          newsId: numericNewsId,
          action: action,
          articleData: articleData,
          retryCount: 0,
          timestamp: Date.now()
        })

        // 网络错误时显示友好提示
        if (action === 'add') {
          showToast('收藏已保存到本地，将在网络恢复时同步')
        } else {
          showToast('已从本地移除，将在网络恢复时同步服务器')
        }
        shouldShowToast = false
      }

      // 显示错误提示（如果需要）
      if (shouldShowToast) {
        if (action === 'add') {
          showToast(`收藏已保存到本地，但${errorMessage}`)
        } else {
          showFailToast(errorMessage)
        }
      }
    } finally {
      syncLoading.value = false
    }
  }

  // 用户登录时合并本地收藏数据
  const mergeLocalFavoritesOnLogin = async () => {
    try {
      console.log('用户登录，开始合并本地收藏数据')

      // 获取本地收藏数据
      const localFavorites = localStorage.getItem('local_favorites')
      if (!localFavorites) {
        console.log('没有本地收藏数据需要合并')
        // 即使没有本地数据，也要从服务器下载用户收藏
        await downloadServerFavorites()
        return
      }

      const localIds = JSON.parse(localFavorites)
      if (localIds.length === 0) {
        console.log('本地收藏数据为空')
        await downloadServerFavorites()
        return
      }

      console.log(`发现 ${localIds.length} 条本地收藏数据，准备合并`)

      try {
        // 从服务器获取用户的收藏列表
        const serverResult = await userDataSyncApi.downloadUserData(['favorite'])
        let serverIds = []

        if (serverResult.code === 200 && serverResult.data.success) {
          serverIds = serverResult.data.downloadData?.map(item => String(item.newsId)) || []
          console.log(`从服务器获取到 ${serverIds.length} 条收藏数据`)
        }

        // 合并本地和服务器收藏ID（去重）
        const mergedIds = [...new Set([...serverIds, ...localIds])]
        console.log(`合并后共 ${mergedIds.length} 条收藏`)

        // 更新本地收藏列表
        favoriteIds.value = mergedIds
        saveFavorites()

        // 如果有新的本地收藏需要上传到服务器
        const newLocalIds = localIds.filter(id => !serverIds.includes(String(id)))
        if (newLocalIds.length > 0) {
          console.log(`需要上传 ${newLocalIds.length} 条新的本地收藏到服务器`)
          await uploadLocalFavoritesToServer(newLocalIds)
        }

        // 清除本地收藏数据
        localStorage.removeItem('local_favorites')
        console.log('本地收藏数据合并完成')

      } catch (error) {
        console.error('从服务器获取收藏数据失败，使用本地合并:', error)

        // 服务器获取失败，使用本地逻辑合并
        const currentUserKey = getStorageKey()
        const existingUserFavorites = localStorage.getItem(currentUserKey)
        let userIds = []

        if (existingUserFavorites) {
          userIds = JSON.parse(existingUserFavorites)
        }

        // 合并去重
        const mergedIds = [...new Set([...userIds, ...localIds])]
        favoriteIds.value = mergedIds
        saveFavorites()

        // 清除本地收藏数据
        localStorage.removeItem('local_favorites')
        console.log(`本地收藏数据合并完成，共 ${mergedIds.length} 条收藏`)

        // 尝试将合并后的数据上传到服务器（后台进行）
        uploadLocalFavoritesToServer(localIds).catch(err => {
          console.error('后台上传收藏数据失败:', err)
        })
      }

    } catch (error) {
      console.error('合并本地收藏数据失败:', error)
    }
  }

  // 从服务器下载收藏数据
  const downloadServerFavorites = async () => {
    try {
      console.log('从服务器下载收藏数据')
      const result = await userDataSyncApi.downloadUserData(['favorite'])

      if (result.code === 200 && result.data.success) {
        const serverFavorites = result.data.downloadData || []
        const serverIds = serverFavorites.map(item => String(item.newsId))

        favoriteIds.value = serverIds
        saveFavorites()

        console.log(`从服务器下载了 ${serverIds.length} 条收藏数据`)
        return serverIds
      }
    } catch (error) {
      console.error('从服务器下载收藏数据失败:', error)
    }
    return []
  }

  // 上传本地收藏到服务器
  const uploadLocalFavoritesToServer = async (newsIds) => {
    try {
      if (!newsIds || newsIds.length === 0) return

      console.log(`准备上传 ${newsIds.length} 条收藏到服务器`)

      // 获取文章详情并构造收藏数据
      const favoriteDataList = []

      for (const newsId of newsIds) {
        try {
          const numericNewsId = parseInt(newsId)
          if (isNaN(numericNewsId)) continue

          // 尝试获取文章详情
          let article = null
          try {
            const response = await articleApi.getArticleDetail(numericNewsId)
            if (response.code === 200) {
              article = response.data
            }
          } catch (error) {
            console.warn(`获取文章 ${numericNewsId} 详情失败:`, error)
          }

          // 构造收藏数据（即使没有详情也要上传ID）
          favoriteDataList.push({
            newsId: numericNewsId,
            title: article?.title || `文章 ${numericNewsId}`,
            url: article?.url || `/news/${numericNewsId}`,
            category: article?.category || '',
            section: article?.section || '',
            favoriteTime: new Date().toISOString()
          })
        } catch (error) {
          console.error(`处理收藏文章 ${newsId} 失败:`, error)
        }
      }

      if (favoriteDataList.length > 0) {
        const result = await userDataSyncApi.uploadFavorites(favoriteDataList, {
          overwriteConflicts: false // 不覆盖已存在的收藏
        })

        if (result.code === 200 && result.data.success) {
          console.log(`成功上传 ${favoriteDataList.length} 条收藏到服务器`)
          showToast(`已同步 ${favoriteDataList.length} 条收藏到服务器`)
        } else {
          throw new Error(result.data?.errorMessage || '上传失败')
        }
      }
    } catch (error) {
      console.error('上传收藏到服务器失败:', error)
      // 加入离线队列
      syncManager.addToSyncQueue({
        syncType: 'upload',
        dataTypes: ['favorite'],
        newsIds: newsIds
      })
    }
  }

  // 用户登出时清除用户收藏数据
  const clearUserFavoritesOnLogout = () => {
    try {
      console.log('用户登出，清除用户收藏数据')

      // 清除当前用户的收藏数据
      const currentUserKey = getStorageKey()
      localStorage.removeItem(currentUserKey)

      // 重置为空状态
      favoriteIds.value = []
      favoriteArticles.value = []

      // 重新初始化（会加载local_favorites如果存在）
      initFavorites()

      console.log('用户收藏数据已清除，切换到本地收藏模式')

    } catch (error) {
      console.error('清除用户收藏数据失败:', error)
    }
  }

  // 判断错误是否为临时错误（不应移除文章）
  const isTemporaryError = (error) => {
    // 网络超时错误
    if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
      return true
    }

    // 网络连接错误
    if (error.code === 'NETWORK_ERROR' || error.message?.includes('Network Error')) {
      return true
    }

    // 服务器繁忙（5xx错误）
    if (error.response?.status >= 500) {
      return true
    }

    // 数据格式错误（通常是前端代码问题）
    if (error.message?.includes('is not a function') ||
        error.message?.includes('Cannot read property') ||
        error.message?.includes('Cannot access before initialization')) {
      return true
    }

    return false
  }

  // 判断错误是否为永久错误（应该移除文章）
  const isPermanentError = (error) => {
    // 404错误 - 文章不存在
    if (error.response?.status === 404) {
      return true
    }

    // 410错误 - 文章已被删除
    if (error.response?.status === 410) {
      return true
    }

    return false
  }

  // 带重试的文章获取函数
  const fetchArticleWithRetry = async (articleApi, id, maxRetries = 2) => {
    let lastError = null

    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        const data = await articleApi.getArticleDetail(id)

        let article
        if (data && data.code === 200) {
          article = data.data
        } else if (data && typeof data === 'object') {
          article = data
        } else {
          throw new Error('Invalid response format')
        }

        // 验证文章数据的完整性
        if (article && (article.news_id || article.newsId)) {
          return { success: true, article, error: null }
        } else {
          // 数据格式问题，但不是网络错误
          console.warn(`文章 ${id} 数据格式异常，但保留收藏:`, article)
          return {
            success: false,
            article: null,
            error: new Error('Data format issue'),
            shouldRemove: false
          }
        }
      } catch (error) {
        lastError = error
        console.warn(`获取文章 ${id} 详情失败 (尝试 ${attempt + 1}/${maxRetries + 1}):`, error.message)

        // 如果是永久错误，不需要重试
        if (isPermanentError(error)) {
          return {
            success: false,
            article: null,
            error,
            shouldRemove: true
          }
        }

        // 如果是临时错误且还有重试机会，等待后重试
        if (isTemporaryError(error) && attempt < maxRetries) {
          await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1))) // 递增延迟
          continue
        }
      }
    }

    // 所有重试都失败了
    return {
      success: false,
      article: null,
      error: lastError,
      shouldRemove: isTemporaryError(lastError) ? false : true // 临时错误不移除
    }
  }

  const loadFavoriteArticles = async (articleApi) => {
    try {
      loading.value = true

      if (favoriteIds.value.length === 0) {
        favoriteArticles.value = []
        return { success: true, articles: [] }
      }

      const articles = []
      const failedIds = []
      const temporaryFailedIds = []

      console.log(`开始加载 ${favoriteIds.value.length} 篇收藏文章`)

      // 批量获取文章详情（带重试机制）
      for (const id of favoriteIds.value) {
        const result = await fetchArticleWithRetry(articleApi, id)

        if (result.success) {
          articles.push(result.article)
        } else {
          if (result.shouldRemove) {
            console.log(`文章 ${id} 确认失效，将从收藏中移除:`, result.error.message)
            failedIds.push(id)
          } else {
            console.warn(`文章 ${id} 暂时无法加载，但保留收藏:`, result.error.message)
            temporaryFailedIds.push(id)
          }
        }
      }

      // 只移除确认失效的文章ID
      if (failedIds.length > 0) {
        console.log(`移除确认失效的收藏文章ID:`, failedIds)
        favoriteIds.value = favoriteIds.value.filter(id => !failedIds.includes(id))
        saveFavorites()
      }

      // 记录临时失败的文章（不移除）
      if (temporaryFailedIds.length > 0) {
        console.log(`暂时无法加载的文章ID（已保留收藏）:`, temporaryFailedIds)
      }

      // 按收藏时间倒序排列（最新收藏的在前面）
      favoriteArticles.value = articles.reverse()

      return {
        success: true,
        articles: favoriteArticles.value,
        removedCount: failedIds.length,
        temporaryFailedCount: temporaryFailedIds.length,
        totalRequested: favoriteIds.value.length + failedIds.length
      }
    } catch (error) {
      console.error('加载收藏文章失败:', error)
      return { success: false, error: error.message }
    } finally {
      loading.value = false
    }
  }

  const removeFavorites = (newsIds) => {
    let removedCount = 0
    newsIds.forEach(newsId => {
      if (removeFavorite(newsId)) {
        removedCount++
      }
    })
    return removedCount
  }

  const clearAllFavorites = () => {
    favoriteIds.value = []
    favoriteArticles.value = []

    // 清除当前存储key的数据
    const storageKey = getStorageKey()
    localStorage.removeItem(storageKey)

    // 也清除旧的存储key（兼容性）
    localStorage.removeItem('favorites')

    console.log(`已清除所有收藏数据 (${storageKey})`)
  }

  const getFavoriteArticle = (newsId) => {
    return favoriteArticles.value.find(
      article => (article.news_id || article.newsId) === newsId
    )
  }

  const updateFavoriteArticle = (newsId, updates) => {
    const index = favoriteArticles.value.findIndex(
      article => (article.news_id || article.newsId) === newsId
    )
    if (index > -1) {
      favoriteArticles.value[index] = { ...favoriteArticles.value[index], ...updates }
    }
  }

  // 初始化时自动恢复收藏数据
  initFavorites()

  return {
    // 状态
    favoriteIds,
    favoriteArticles,
    loading,
    syncLoading,

    // 计算属性
    favoriteCount,
    isFavorited,
    isEmpty,

    // Actions
    initFavorites,
    addFavorite,
    removeFavorite,
    toggleFavorite,
    loadFavoriteArticles,
    removeFavorites,
    clearAllFavorites,
    getFavoriteArticle,
    updateFavoriteArticle,

    // 用户状态变化处理
    mergeLocalFavoritesOnLogin,
    clearUserFavoritesOnLogout,

    // 服务器同步相关
    syncFavoriteToServer,
    downloadServerFavorites,
    uploadLocalFavoritesToServer
  }
})
